
// 作用：类型注解 类型推断

// 知识点：数据类型 （基本类型 / 引用类型） 函数 class 接口 泛型

// :类型
// :联合类型 string | number

// any:任意类型 (跳过类型检测) 你比ts还了解你的类型，就可以 用 断言；
// void: 空。
// never: 错误

// 得出结论：
// 1. 凡是别人传递给我，都要注解
// 2. 谁定义，谁注解

const num: 1 = 1;
let str:string | number = '123';
str = 1231212;

let boo:boolean = true;
let n:any = null; // 占位
n = 1;
n = '1'
n = true
let u = undefined;


// array function object

// 接口
// interface ArrProps {
//   key : (null | number | string | boolean)
// }

// 类型接口
type ArrProps = (null | number | string | boolean)

// tuple 元组
const arr: ArrProps[] = [null, 1, '124', true];

type ParamsProps = number | string;

// 函数注解: 参数 返回值
function auto(params:  ParamsProps): ParamsProps  {

  return params;
}

auto(12)

type OptProps = {
  name?: string,
  address?: string,
  avatar?: string
}

// 接口
interface EchoProps {
  page?: number,
  size: number | string,
  success?: (arg: OptProps) =>  void, // ? 可传可不传
  opt: OptProps,
  list?: number[]
}

function echo({ page, size, success, opt, list }: EchoProps)  {

  // ? 用在执行代码的时候，
  // list?.map(item => {

  // })

  success && success({})

  return { page: page && page + 1, size };
}

echo({
  page: 1,
  size: '5',
  // 回调函数： 一个函数，作为参数，
  success: function(arg) {
    console.log('arg:', arg)
  },
  opt: {
    name: 'devin',
    address: '地址'
  },
  list: [1,2,3,4,4]
})

// 泛型

// [1,2]  [2, 1]
function swap<T, U>(arg: [T, U]) : [U, T] {
  return [arg[1], arg[0]]
}

swap([1, '2'])

// 队列 数据
class Queue<T> {

  private list:T[] = [];

  push(item:T) {
    this.list.push(item) // 只要报never就说明，没有注解好
    console.log('this', this.list)
  }
  pop() {
    return this.list.pop()
  }
}

const q1 = new Queue<number>()
const q2 = new Queue<string>()
q2.push('3')

q2.pop() // ts提示功能



/**
 *
 * 1. 数据基本类型
 * 2. 应用类型（array / function / object）
 * 3. 类class
 *
 * 4. 接口（interface / type）
 * 5. 泛型：
 *
 * 6. any / void / never
 *
 * 7.  凡是别人传递给我，都要注解(函数参数 props) / 谁定义，谁注解 (注解在定义的地方)
 *
 * 8. 声明文件：
 *
 *
 */
